home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / binutils.7 / binutils / binutils-2.7 / gas / config / tc-tahoe.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-04  |  58.3 KB  |  2,028 lines
  1. /* tc-tahoe.c
  2.    Not part of GAS yet. */
  3.  
  4. #include "as.h"
  5. #include "obstack.h"
  6.  
  7. /* this bit glommed from tahoe-inst.h */
  8.  
  9. typedef unsigned char byte;
  10. typedef byte tahoe_opcodeT;
  11.  
  12. /*
  13.  * This is part of tahoe-ins-parse.c & friends.
  14.  * We want to parse a tahoe instruction text into a tree defined here.
  15.  */
  16.  
  17. #define TIT_MAX_OPERANDS (4)    /* maximum number of operands in one
  18.                    single tahoe instruction */
  19.  
  20. struct top            /* tahoe instruction operand */
  21. {
  22.   int top_ndx;            /* -1, or index register. eg 7=[R7] */
  23.   int top_reg;            /* -1, or register number. eg 7 = R7 or (R7) */
  24.   byte top_mode;        /* Addressing mode byte. This byte, defines
  25.                    which of the 11 modes opcode is. */
  26.  
  27.   char top_access;        /* Access type wanted for this opperand
  28.                    'b'branch ' 'no-instruction 'amrvw' */
  29.   char top_width;        /* Operand width expected, one of "bwlq?-:!" */
  30.  
  31.   char *top_error;        /* Say if operand is inappropriate         */
  32.  
  33.   segT seg_of_operand;        /* segment as returned by expression()*/
  34.  
  35.   expressionS exp_of_operand;    /* The expression as parsed by expression()*/
  36.  
  37.   byte top_dispsize;        /* Number of bytes in the displacement if we
  38.                    can figure it out */
  39. };
  40.  
  41. /* The addressing modes for an operand. These numbers are the acutal values
  42.    for certain modes, so be carefull if you screw with them. */
  43. #define TAHOE_DIRECT_REG (0x50)
  44. #define TAHOE_REG_DEFERRED (0x60)
  45.  
  46. #define TAHOE_REG_DISP (0xE0)
  47. #define TAHOE_REG_DISP_DEFERRED (0xF0)
  48.  
  49. #define TAHOE_IMMEDIATE (0x8F)
  50. #define TAHOE_IMMEDIATE_BYTE (0x88)
  51. #define TAHOE_IMMEDIATE_WORD (0x89)
  52. #define TAHOE_IMMEDIATE_LONGWORD (0x8F)
  53. #define TAHOE_ABSOLUTE_ADDR (0x9F)
  54.  
  55. #define TAHOE_DISPLACED_RELATIVE (0xEF)
  56. #define TAHOE_DISP_REL_DEFERRED (0xFF)
  57.  
  58. #define TAHOE_AUTO_DEC (0x7E)
  59. #define TAHOE_AUTO_INC (0x8E)
  60. #define TAHOE_AUTO_INC_DEFERRED (0x9E)
  61. /* INDEXED_REG is decided by the existance or lack of a [reg] */
  62.  
  63. /* These are encoded into top_width when top_access=='b'
  64.    and it's a psuedo op.*/
  65. #define TAHOE_WIDTH_ALWAYS_JUMP      '-'
  66. #define TAHOE_WIDTH_CONDITIONAL_JUMP '?'
  67. #define TAHOE_WIDTH_BIG_REV_JUMP     '!'
  68. #define TAHOE_WIDTH_BIG_NON_REV_JUMP ':'
  69.  
  70. /* The hex code for certain tahoe commands and modes.
  71.    This is just for readability. */
  72. #define TAHOE_JMP (0x71)
  73. #define TAHOE_PC_REL_LONG (0xEF)
  74. #define TAHOE_BRB (0x11)
  75. #define TAHOE_BRW (0x13)
  76. /* These, when 'ored' with, or added to, a register number,
  77.    set up the number for the displacement mode. */
  78. #define TAHOE_PC_OR_BYTE (0xA0)
  79. #define TAHOE_PC_OR_WORD (0xC0)
  80. #define TAHOE_PC_OR_LONG (0xE0)
  81.  
  82. struct tit            /* get it out of the sewer, it stands for
  83.                    tahoe instruction tree (Geeze!) */
  84. {
  85.   tahoe_opcodeT tit_opcode;    /* The opcode. */
  86.   byte tit_operands;        /* How many operands are here. */
  87.   struct top tit_operand[TIT_MAX_OPERANDS];    /* Operands */
  88.   char *tit_error;        /* "" or fatal error text */
  89. };
  90.  
  91. /* end: tahoe-inst.h */
  92.  
  93. /* tahoe.c - tahoe-specific -
  94.    Not part of gas yet.
  95.    */
  96.  
  97. #include "opcode/tahoe.h"
  98.  
  99. /* This is the number to put at the beginning of the a.out file */
  100. long omagic = OMAGIC;
  101.  
  102. /* These chars start a comment anywhere in a source file (except inside
  103.    another comment or a quoted string. */
  104. const char comment_chars[] = "#;";
  105.  
  106. /* These chars only start a comment at the beginning of a line. */
  107. const char line_comment_chars[] = "#";
  108.  
  109. /* Chars that can be used to separate mant from exp in floating point nums */
  110. const char EXP_CHARS[] = "eE";
  111.  
  112. /* Chars that mean this number is a floating point constant
  113.    as in 0f123.456
  114.    or    0d1.234E-12 (see exp chars above)
  115.    Note: The Tahoe port doesn't support floating point constants. This is
  116.          consistant with 'as' If it's needed, I can always add it later. */
  117. const char FLT_CHARS[] = "df";
  118.  
  119. /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
  120.    changed in read.c .  Ideally it shouldn't have to know about it at all,
  121.    but nothing is ideal around here.
  122.    (The tahoe has plenty of room, so the change currently isn't needed.)
  123.    */
  124.  
  125. static struct tit t;        /* A tahoe instruction after decoding. */
  126.  
  127. void float_cons ();
  128. /* A table of pseudo ops (sans .), the function called, and an integer op
  129.    that the function is called with. */
  130.  
  131. const pseudo_typeS md_pseudo_table[] =
  132. {
  133.   {"dfloat", float_cons, 'd'},
  134.   {"ffloat", float_cons, 'f'},
  135.   {0}
  136. };
  137.  
  138. /*
  139.  * For Tahoe, relative addresses of "just the right length" are pretty easy.
  140.  * The branch displacement is always the last operand, even in
  141.  * synthetic instructions.
  142.  * For Tahoe, we encode the relax_substateTs (in e.g. fr_substate) as:
  143.  *
  144.  *            4       3       2       1       0         bit number
  145.  *    ---/ /--+-------+-------+-------+-------+-------+
  146.  *        |     what state ?    |  how long ?    |
  147.  *    ---/ /--+-------+-------+-------+-------+-------+
  148.  *
  149.  * The "how long" bits are 00=byte, 01=word, 10=long.
  150.  * This is a Un*x convention.
  151.  * Not all lengths are legit for a given value of (what state).
  152.  * The four states are listed below.
  153.  * The "how long" refers merely to the displacement length.
  154.  * The address usually has some constant bytes in it as well.
  155.  *
  156.  
  157. States for Tahoe address relaxing.
  158. 1.    TAHOE_WIDTH_ALWAYS_JUMP (-)
  159.     Format: "b-"
  160.     Tahoe opcodes are:    (Hex)
  161.         jr        11
  162.         jbr        11
  163.     Simple branch.
  164.     Always, 1 byte opcode, then displacement/absolute.
  165.     If word or longword, change opcode to brw or jmp.
  166.  
  167.     
  168. 2.    TAHOE_WIDTH_CONDITIONAL_JUMP (?)
  169.     J<cond> where <cond> is a simple flag test.
  170.     Format: "b?"
  171.     Tahoe opcodes are:    (Hex)
  172.         jneq/jnequ    21
  173.         jeql/jeqlu    31
  174.         jgtr        41
  175.         jleq        51
  176.         jgeq        81
  177.         jlss        91
  178.         jgtru        a1
  179.         jlequ        b1
  180.         jvc        c1
  181.         jvs        d1
  182.         jlssu/jcs    e1
  183.         jgequ/jcc    f1
  184.     Always, you complement 4th bit to reverse the condition.
  185.     Always, 1-byte opcode, then 1-byte displacement.
  186.  
  187. 3.    TAHOE_WIDTH_BIG_REV_JUMP (!)
  188.     Jbc/Jbs where cond tests a memory bit.
  189.     Format: "rlvlb!"
  190.     Tahoe opcodes are:    (Hex)
  191.         jbs        0e
  192.         jbc        1e
  193.     Always, you complement 4th bit to reverse the condition.
  194.     Always, 1-byte opcde, longword, longword-address, 1-word-displacement
  195.  
  196. 4.    TAHOE_WIDTH_BIG_NON_REV_JUMP (:)
  197.     JaoblXX/Jbssi
  198.     Format: "rlmlb:"
  199.     Tahoe opcodes are:    (Hex)
  200.         aojlss        2f
  201.         jaoblss        2f
  202.         aojleq        3f
  203.         jaobleq        3f
  204.         jbssi        5f
  205.     Always, we cannot reverse the sense of the branch; we have a word
  206.     displacement.
  207.  
  208. We need to modify the opcode is for class 1, 2 and 3 instructions.
  209. After relax() we may complement the 4th bit of 2 or 3 to reverse sense of
  210. branch.
  211.  
  212. We sometimes store context in the operand literal. This way we can figure out
  213. after relax() what the original addressing mode was. (Was is pc_rel, or
  214. pc_rel_disp? That sort of thing.) */
  215.  
  216. /* These displacements are relative to the START address of the
  217.    displacement which is at the start of the displacement, not the end of
  218.    the instruction. The hardware pc_rel is at the end of the instructions.
  219.    That's why all the displacements have the length of the displacement added
  220.    to them. (WF + length(word))
  221.  
  222.    The first letter is Byte, Word.
  223.    2nd letter is Forward, Backward. */
  224. #define BF (1+ 127)
  225. #define BB (1+-128)
  226. #define WF (2+ 32767)
  227. #define WB (2+-32768)
  228. /* Dont need LF, LB because they always reach. [They are coded as 0.] */
  229.  
  230. #define C(a,b) ENCODE_RELAX(a,b)
  231. /* This macro has no side-effects. */
  232. #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
  233. #define RELAX_STATE(what) ((what) >> 2)
  234. #define RELAX_LENGTH(length) ((length) && 3)
  235.  
  236. #define STATE_ALWAYS_BRANCH             (1)
  237. #define STATE_CONDITIONAL_BRANCH        (2)
  238. #define STATE_BIG_REV_BRANCH            (3)
  239. #define STATE_BIG_NON_REV_BRANCH        (4)
  240. #define STATE_PC_RELATIVE        (5)
  241.  
  242. #define STATE_BYTE                      (0)
  243. #define STATE_WORD                      (1)
  244. #define STATE_LONG                      (2)
  245. #define STATE_UNDF                      (3)    /* Symbol undefined in pass1 */
  246.  
  247. /* This is the table used by gas to figure out relaxing modes. The fields are
  248.    forward_branch reach, backward_branch reach, number of bytes it would take,
  249.    where the next biggest branch is. */
  250. const relax_typeS md_relax_table[] =
  251. {
  252.   {
  253.     1, 1, 0, 0
  254.   },                /* error sentinel   0,0    */
  255.   {
  256.     1, 1, 0, 0
  257.   },                /* unused        0,1    */
  258.   {
  259.     1, 1, 0, 0
  260.   },                /* unused        0,2    */
  261.   {
  262.     1, 1, 0, 0
  263.   },                /* unused        0,3    */
  264. /* Unconditional branch cases "jrb"
  265.      The relax part is the actual displacement */
  266.   {
  267.     BF, BB, 1, C (1, 1)
  268.   },                /* brb B`foo        1,0 */
  269.   {
  270.     WF, WB, 2, C (1, 2)
  271.   },                /* brw W`foo        1,1 */
  272.   {
  273.     0, 0, 5, 0
  274.   },                /* Jmp L`foo        1,2 */
  275.   {
  276.     1, 1, 0, 0
  277.   },                /* unused        1,3 */
  278. /* Reversible Conditional Branch. If the branch won't reach, reverse
  279.      it, and jump over a brw or a jmp that will reach. The relax part is the
  280.      actual address. */
  281.   {
  282.     BF, BB, 1, C (2, 1)
  283.   },                /* b<cond> B`foo    2,0 */
  284.   {
  285.     WF + 2, WB + 2, 4, C (2, 2)
  286.   },                /* brev over, brw W`foo, over: 2,1 */
  287.   {
  288.     0, 0, 7, 0
  289.   },                /* brev over, jmp L`foo, over: 2,2 */
  290.   {
  291.     1, 1, 0, 0
  292.   },                /* unused        2,3 */
  293. /* Another type of reversable branch. But this only has a word
  294.      displacement. */
  295.   {
  296.     1, 1, 0, 0
  297.   },                /* unused        3,0 */
  298.   {
  299.     WF, WB, 2, C (3, 2)
  300.   },                /* jbX W`foo        3,1 */
  301.   {
  302.     0, 0, 8, 0
  303.   },                /* jrevX over, jmp L`foo, over:  3,2 */
  304.   {
  305.     1, 1, 0, 0
  306.   },                /* unused        3,3 */
  307. /* These are the non reversable branches, all of which have a word
  308.      displacement. If I can't reach, branch over a byte branch, to a
  309.      jump that will reach. The jumped branch jumps over the reaching
  310.      branch, to continue with the flow of the program. It's like playing
  311.      leap frog. */
  312.   {
  313.     1, 1, 0, 0
  314.   },                /* unused        4,0 */
  315.   {
  316.     WF, WB, 2, C (4, 2)
  317.   },                /* aobl_ W`foo        4,1 */
  318.   {
  319.     0, 0, 10, 0
  320.   },                /*aobl_ W`hop,br over,hop: jmp L^foo,over 4,2*/
  321.   {
  322.     1, 1, 0, 0
  323.   },                /* unused        4,3 */
  324. /* Normal displacement mode, no jumping or anything like that.
  325.      The relax points to one byte before the address, thats why all
  326.      the numbers are up by one. */
  327.   {
  328.     BF + 1, BB + 1, 2, C (5, 1)
  329.   },                /* B^"foo"        5,0 */
  330.   {
  331.     WF + 1, WB + 1, 3, C (5, 2)
  332.   },                /* W^"foo"        5,1 */
  333.   {
  334.     0, 0, 5, 0
  335.   },                /* L^"foo"        5,2 */
  336.   {
  337.     1, 1, 0, 0
  338.   },                /* unused        5,3 */
  339. };
  340.  
  341. #undef C
  342. #undef BF
  343. #undef BB
  344. #undef WF
  345. #undef WB
  346. /* End relax stuff */
  347.  
  348. /* Handle of the OPCODE hash table.  NULL means any use before
  349.    md_begin() will crash.  */
  350. static struct hash_control *op_hash;
  351.  
  352. /* Init function. Build the hash table. */
  353. void
  354. md_begin ()
  355. {
  356.   struct tot *tP;
  357.   char *errorval = 0;
  358.   int synthetic_too = 1;    /* If 0, just use real opcodes. */
  359.  
  360.   op_hash = hash_new ();
  361.  
  362.   for (tP = totstrs; *tP->name && !errorval; tP++)
  363.     errorval = hash_insert (op_hash, tP->name, &tP->detail);
  364.  
  365.   if (synthetic_too)
  366.     for (tP = synthetic_totstrs; *tP->name && !errorval; tP++)
  367.       errorval = hash_insert (op_hash, tP->name, &tP->detail);
  368.  
  369.   if (errorval)
  370.     as_fatal (errorval);
  371. }
  372.  
  373. CONST char *md_shortopts = "ad:STt:V";
  374. struct option md_longopts[] = {
  375.   {NULL, no_argument, NULL, 0}
  376. };
  377. size_t md_longopts_size = sizeof(md_longopts);
  378.  
  379. int
  380. md_parse_option (c, arg)
  381.      int c;
  382.      char *arg;
  383. {
  384.   switch (c)
  385.     {
  386.     case 'a':
  387.       as_warn ("The -a option doesn't exist. (Despite what the man page says!");
  388.       break;
  389.  
  390.     case 'd':
  391.       as_warn ("Displacement length %s ignored!", arg);
  392.       break;
  393.  
  394.     case 'S':
  395.       as_warn ("SYMBOL TABLE not implemented");
  396.       break;
  397.  
  398.     case 'T':
  399.       as_warn ("TOKEN TRACE not implemented");
  400.       break;
  401.  
  402.     case 't':
  403.       as_warn ("I don't need or use temp. file \"%s\".", arg);
  404.       break;
  405.  
  406.     case 'V':
  407.       as_warn ("I don't use an interpass file! -V ignored");
  408.       break;
  409.  
  410.     default:
  411.       return 0;
  412.     }
  413.  
  414.   return 1;
  415. }
  416.  
  417. void
  418. md_show_usage (stream)
  419.      FILE *stream;
  420. {
  421.   fprintf(stream, "\
  422. Tahoe options:\n\
  423. -a            ignored\n\
  424. -d LENGTH        ignored\n\
  425. -J            ignored\n\
  426. -S            ignored\n\
  427. -t FILE            ignored\n\
  428. -T            ignored\n\
  429. -V            ignored\n");
  430. }
  431.  
  432. /* The functions in this section take numbers in the machine format, and
  433.    munges them into Tahoe byte order.
  434.    They exist primarily for cross assembly purpose. */
  435. void                /* Knows about order of bytes in address. */
  436. md_number_to_chars (con, value, nbytes)
  437.      char con[];        /* Return 'nbytes' of chars here. */
  438.      valueT value;        /* The value of the bits. */
  439.      int nbytes;        /* Number of bytes in the output. */
  440. {
  441.   number_to_chars_bigendian (con, value, nbytes);
  442. }
  443.  
  444. #ifdef comment
  445. void                /* Knows about order of bytes in address. */
  446. md_number_to_imm (con, value, nbytes)
  447.      char con[];        /* Return 'nbytes' of chars here. */
  448.      long int value;        /* The value of the bits. */
  449.      int nbytes;        /* Number of bytes in the output. */
  450. {
  451.   md_number_to_chars (con, value, nbytes);
  452. }
  453.  
  454. #endif /* comment */
  455.  
  456. void
  457. tc_apply_fix (fixP, val)
  458.      fixS *fixP;
  459.      long val;
  460. {
  461.   /* should never be called */
  462.   know (0);
  463. }
  464.  
  465. void                /* Knows about order of bytes in address. */
  466. md_number_to_disp (con, value, nbytes)
  467.      char con[];        /* Return 'nbytes' of chars here. */
  468.      long int value;        /* The value of the bits. */
  469.      int nbytes;        /* Number of bytes in the output. */
  470. {
  471.   md_number_to_chars (con, value, nbytes);
  472. }
  473.  
  474. void                /* Knows about order of bytes in address. */
  475. md_number_to_field (con, value, nbytes)
  476.      char con[];        /* Return 'nbytes' of chars here. */
  477.      long int value;        /* The value of the bits. */
  478.      int nbytes;        /* Number of bytes in the output. */
  479. {
  480.   md_number_to_chars (con, value, nbytes);
  481. }
  482.  
  483. /* Put the bits in an order that a tahoe will understand, despite the ordering
  484.    of the native machine.
  485.    On Tahoe: first 4 bytes are normal unsigned big endian long,
  486.    next three bytes are symbolnum, in kind of 3 byte big endian (least sig. byte last).
  487.    The last byte is broken up with bit 7 as pcrel,
  488.        bits 6 & 5 as length,
  489.     bit 4 as extern and the last nibble as 'undefined'. */
  490.  
  491. #if comment
  492. void
  493. md_ri_to_chars (ri_p, ri)
  494.      struct relocation_info *ri_p, ri;
  495. {
  496.   byte the_bytes[sizeof (struct relocation_info)];
  497.   /* The reason I can't just encode these directly into ri_p is that
  498.      ri_p may point to ri. */
  499.  
  500.   /* This is easy */
  501.   md_number_to_chars (the_bytes, ri.r_address, sizeof (ri.r_address));
  502.  
  503.   /* now the fun stuff */
  504.   the_bytes[4] = (ri.r_symbolnum >> 16) & 0x0ff;
  505.   the_bytes[5] = (ri.r_symbolnum >> 8) & 0x0ff;
  506.   the_bytes[6] = ri.r_symbolnum & 0x0ff;
  507.   the_bytes[7] = (((ri.r_extern << 4) & 0x10) | ((ri.r_length << 5) & 0x60) |
  508.           ((ri.r_pcrel << 7) & 0x80)) & 0xf0;
  509.  
  510.   bcopy (the_bytes, (char *) ri_p, sizeof (struct relocation_info));
  511. }
  512.  
  513. #endif /* comment */
  514.  
  515. /* Put the bits in an order that a tahoe will understand, despite the ordering
  516.    of the native machine.
  517.    On Tahoe: first 4 bytes are normal unsigned big endian long,
  518.    next three bytes are symbolnum, in kind of 3 byte big endian (least sig. byte last).
  519.    The last byte is broken up with bit 7 as pcrel,
  520.        bits 6 & 5 as length,
  521.     bit 4 as extern and the last nibble as 'undefined'. */
  522.  
  523. void 
  524. tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
  525.      char *where;
  526.      fixS *fixP;
  527.      relax_addressT segment_address_in_file;
  528. {
  529.   long r_symbolnum;
  530.  
  531.   know (fixP->fx_addsy != NULL);
  532.  
  533.   md_number_to_chars (where,
  534.        fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
  535.               4);
  536.  
  537.   r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
  538.          ? S_GET_TYPE (fixP->fx_addsy)
  539.          : fixP->fx_addsy->sy_number);
  540.  
  541.   where[4] = (r_symbolnum >> 16) & 0x0ff;
  542.   where[5] = (r_symbolnum >> 8) & 0x0ff;
  543.   where[6] = r_symbolnum & 0x0ff;
  544.   where[7] = (((is_pcrel (fixP) << 7) & 0x80)
  545.           | ((((fixP->fx_type == FX_8 || fixP->fx_type == FX_PCREL8
  546.             ? 0
  547.             : (fixP->fx_type == FX_16 || fixP->fx_type == FX_PCREL16
  548.                ? 1
  549.             : (fixP->fx_type == FX_32 || fixP->fx_type == FX_PCREL32
  550.                ? 2
  551.                : 42)))) << 5) & 0x60)
  552.           | ((!S_IS_DEFINED (fixP->fx_addsy) << 4) & 0x10));
  553. }
  554.  
  555. /* Relocate byte stuff */
  556.  
  557. /* This is for broken word. */
  558. const int md_short_jump_size = 3;
  559.  
  560. void
  561. md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
  562.      char *ptr;
  563.      addressT from_addr, to_addr;
  564.      fragS *frag;
  565.      symbolS *to_symbol;
  566. {
  567.   valueT offset;
  568.  
  569.   offset = to_addr - (from_addr + 1);
  570.   *ptr++ = TAHOE_BRW;
  571.   md_number_to_chars (ptr, offset, 2);
  572. }
  573.  
  574. const int md_long_jump_size = 6;
  575. const int md_reloc_size = 8;    /* Size of relocation record */
  576.  
  577. void
  578. md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
  579.      char *ptr;
  580.      addressT from_addr, to_addr;
  581.      fragS *frag;
  582.      symbolS *to_symbol;
  583. {
  584.   valueT offset;
  585.  
  586.   offset = to_addr - (from_addr + 4);
  587.   *ptr++ = TAHOE_JMP;
  588.   *ptr++ = TAHOE_PC_REL_LONG;
  589.   md_number_to_chars (ptr, offset, 4);
  590. }
  591.  
  592. /*
  593.  *            md_estimate_size_before_relax()
  594.  *
  595.  * Called just before relax().
  596.  * Any symbol that is now undefined will not become defined, so we assumed
  597.  * that it will be resolved by the linker.
  598.  * Return the correct fr_subtype in the frag, for relax()
  599.  * Return the initial "guess for fr_var" to caller. (How big I think this
  600.  * will be.)
  601.  * The guess for fr_var is ACTUALLY the growth beyond fr_fix.
  602.  * Whatever we do to grow fr_fix or fr_var contributes to our returned value.
  603.  * Although it may not be explicit in the frag, pretend fr_var starts with a
  604.  * 0 value.
  605.  */
  606. int
  607. md_estimate_size_before_relax (fragP, segment_type)
  608.      register fragS *fragP;
  609.      segT segment_type;        /* N_DATA or N_TEXT. */
  610. {
  611.   register char *p;
  612.   register int old_fr_fix;
  613.   /*  int pc_rel; FIXME: remove this */
  614.  
  615.   old_fr_fix = fragP->fr_fix;
  616.   switch (fragP->fr_subtype)
  617.     {
  618.     case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_UNDF):
  619.       if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
  620.     {
  621.       /* The symbol was in the same segment as the opcode, and it's
  622.      a real pc_rel case so it's a relaxable case. */
  623.       fragP->fr_subtype = ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE);
  624.     }
  625.       else
  626.     {
  627.       /* This case is still undefined, so asume it's a long word for the
  628.      linker to fix. */
  629.       p = fragP->fr_literal + old_fr_fix;
  630.       *p |= TAHOE_PC_OR_LONG;
  631.       /* We now know how big it will be, one long word. */
  632.       fragP->fr_fix += 1 + 4;
  633.       fix_new (fragP, old_fr_fix + 1, fragP->fr_symbol,
  634.            fragP->fr_offset, FX_PCREL32, NULL);
  635.       frag_wane (fragP);
  636.     }
  637.       break;
  638.  
  639.     case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_UNDF):
  640.       if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
  641.     {
  642.       fragP->fr_subtype = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE);
  643.     }
  644.       else
  645.     {
  646.       p = fragP->fr_literal + old_fr_fix;
  647.       *fragP->fr_opcode ^= 0x10;    /* Reverse sense of branch. */
  648.       *p++ = 6;
  649.       *p++ = TAHOE_JMP;
  650.       *p++ = TAHOE_PC_REL_LONG;
  651.       fragP->fr_fix += 1 + 1 + 1 + 4;
  652.       fix_new (fragP, old_fr_fix + 3, fragP->fr_symbol,
  653.            fragP->fr_offset, FX_PCREL32, NULL);
  654.       frag_wane (fragP);
  655.     }
  656.       break;
  657.  
  658.     case ENCODE_RELAX (STATE_BIG_REV_BRANCH, STATE_UNDF):
  659.       if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
  660.     {
  661.       fragP->fr_subtype =
  662.         ENCODE_RELAX (STATE_BIG_REV_BRANCH, STATE_WORD);
  663.     }
  664.       else
  665.     {
  666.       p = fragP->fr_literal + old_fr_fix;
  667.       *fragP->fr_opcode ^= 0x10;    /* Reverse sense of branch. */
  668.       *p++ = 0;
  669.       *p++ = 6;
  670.       *p++ = TAHOE_JMP;
  671.       *p++ = TAHOE_PC_REL_LONG;
  672.       fragP->fr_fix += 2 + 2 + 4;
  673.       fix_new (fragP, old_fr_fix + 4, fragP->fr_symbol,
  674.            fragP->fr_offset, FX_PCREL32, NULL);
  675.       frag_wane (fragP);
  676.     }
  677.       break;
  678.  
  679.     case ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH, STATE_UNDF):
  680.       if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
  681.     {
  682.       fragP->fr_subtype = ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH, STATE_WORD);
  683.     }
  684.       else
  685.     {
  686.       p = fragP->fr_literal + old_fr_fix;
  687.       *p++ = 2;
  688.       *p++ = 0;
  689.       *p++ = TAHOE_BRB;
  690.       *p++ = 6;
  691.       *p++ = TAHOE_JMP;
  692.       *p++ = TAHOE_PC_REL_LONG;
  693.       fragP->fr_fix += 2 + 2 + 2 + 4;
  694.       fix_new (fragP, old_fr_fix + 6, fragP->fr_symbol,
  695.            fragP->fr_offset, FX_PCREL32, NULL);
  696.       frag_wane (fragP);
  697.     }
  698.       break;
  699.  
  700.     case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_UNDF):
  701.       if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
  702.     {
  703.       fragP->fr_subtype = ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE);
  704.     }
  705.       else
  706.     {
  707.       p = fragP->fr_literal + old_fr_fix;
  708.       *fragP->fr_opcode = TAHOE_JMP;
  709.       *p++ = TAHOE_PC_REL_LONG;
  710.       fragP->fr_fix += 1 + 4;
  711.       fix_new (fragP, old_fr_fix + 1, fragP->fr_symbol,
  712.            fragP->fr_offset, FX_PCREL32, NULL);
  713.       frag_wane (fragP);
  714.     }
  715.       break;
  716.  
  717.     default:
  718.       break;
  719.     }
  720.   return (fragP->fr_var + fragP->fr_fix - old_fr_fix);
  721. }                /* md_estimate_size_before_relax() */
  722.  
  723. /*
  724.  *            md_convert_frag();
  725.  *
  726.  * Called after relax() is finished.
  727.  * In:    Address of frag.
  728.  *    fr_type == rs_machine_dependent.
  729.  *    fr_subtype is what the address relaxed to.
  730.  *
  731.  * Out:    Any fixSs and constants are set up.
  732.  *    Caller will turn frag into a ".space 0".
  733.  */
  734. void
  735. md_convert_frag (headers, seg, fragP)
  736.      object_headers *headers;
  737.      segT seg;
  738.      register fragS *fragP;
  739. {
  740.   register char *addressP;    /* -> _var to change. */
  741.   register char *opcodeP;    /* -> opcode char(s) to change. */
  742.   register short int length_code;    /* 2=long 1=word 0=byte */
  743.   register short int extension = 0;    /* Size of relaxed address.
  744.                    Added to fr_fix: incl. ALL var chars. */
  745.   register symbolS *symbolP;
  746.   register long int where;
  747.   register long int address_of_var;
  748.   /* Where, in file space, is _var of *fragP? */
  749.   register long int target_address;
  750.   /* Where, in file space, does addr point? */
  751.  
  752.   know (fragP->fr_type == rs_machine_dependent);
  753.   length_code = RELAX_LENGTH (fragP->fr_subtype);
  754.   know (length_code >= 0 && length_code < 3);
  755.   where = fragP->fr_fix;
  756.   addressP = fragP->fr_literal + where;
  757.   opcodeP = fragP->fr_opcode;
  758.   symbolP = fragP->fr_symbol;
  759.   know (symbolP);
  760.   target_address = S_GET_VALUE (symbolP) + fragP->fr_offset;
  761.   address_of_var = fragP->fr_address + where;
  762.   switch (fragP->fr_subtype)
  763.     {
  764.     case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE):
  765.       /* *addressP holds the registers number, plus 0x10, if it's deferred
  766.        mode. To set up the right mode, just OR the size of this displacement */
  767.       /* Byte displacement. */
  768.       *addressP++ |= TAHOE_PC_OR_BYTE;
  769.       *addressP = target_address - (address_of_var + 2);
  770.       extension = 2;
  771.       break;
  772.  
  773.     case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_WORD):
  774.       /* Word displacement. */
  775.       *addressP++ |= TAHOE_PC_OR_WORD;
  776.       md_number_to_chars (addressP, target_address - (address_of_var + 3), 2);
  777.       extension = 3;
  778.       break;
  779.  
  780.     case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_LONG):
  781.       /* Long word displacement. */
  782.       *addressP++ |= TAHOE_PC_OR_LONG;
  783.       md_number_to_chars (addressP, target_address - (address_of_var + 5), 4);
  784.       extension = 5;
  785.       break;
  786.  
  787.     case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE):
  788.       *addressP = target_address - (address_of_var + 1);
  789.       extension = 1;
  790.       break;
  791.  
  792.     case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_WORD):
  793.       *opcodeP ^= 0x10;        /* Reverse sense of test. */
  794.       *addressP++ = 3;        /* Jump over word branch */
  795.       *addressP++ = TAHOE_BRW;
  796.       md_number_to_chars (addressP, target_address - (address_of_var + 4), 2);
  797.       extension = 4;
  798.       break;
  799.  
  800.     case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_LONG):
  801.       *opcodeP ^= 0x10;        /* Reverse sense of test. */
  802.       *addressP++ = 6;
  803.       *addressP++ = TAHOE_JMP;
  804.       *addressP++ = TAHOE_PC_REL_LONG;
  805.       md_number_to_chars (addressP, target_address, 4);
  806.       extension = 7;
  807.       break;
  808.  
  809.     case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE):
  810.       *addressP = target_address - (address_of_var + 1);
  811.       extension = 1;
  812.       break;
  813.  
  814.     case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_WORD):
  815.       *opcodeP = TAHOE_BRW;
  816.       md_number_to_chars (addressP, target_address - (address_of_var + 2), 2);
  817.       extension = 2;
  818.       break;
  819.  
  820.     case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_LONG):
  821.       *opcodeP = TAHOE_JMP;
  822.       *addressP++ = TAHOE_PC_REL_LONG;
  823.       md_number_to_chars (addressP, target_address - (address_of_var + 5), 4);
  824.       extension = 5;
  825.       break;
  826.  
  827.     case ENCODE_RELAX (STATE_BIG_REV_BRANCH, STATE_WORD):
  828.       md_number_to_chars (addressP, target_address - (address_of_var + 2), 2);
  829.       extension = 2;
  830.       break;
  831.  
  832.     case ENCODE_RELAX (STATE_BIG_REV_BRANCH, STATE_LONG):
  833.       *opcodeP ^= 0x10;
  834.       *addressP++ = 0;
  835.       *addressP++ = 6;
  836.       *addressP++ = TAHOE_JMP;
  837.       *addressP++ = TAHOE_PC_REL_LONG;
  838.       md_number_to_chars (addressP, target_address, 4);
  839.       extension = 8;
  840.       break;
  841.  
  842.     case ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH, STATE_WORD):
  843.       md_number_to_chars (addressP, target_address - (address_of_var + 2), 2);
  844.       extension = 2;
  845.       break;
  846.  
  847.     case ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH, STATE_LONG):
  848.       *addressP++ = 0;
  849.       *addressP++ = 2;
  850.       *addressP++ = TAHOE_BRB;
  851.       *addressP++ = 6;
  852.       *addressP++ = TAHOE_JMP;
  853.       *addressP++ = TAHOE_PC_REL_LONG;
  854.       md_number_to_chars (addressP, target_address, 4);
  855.       extension = 10;
  856.       break;
  857.  
  858.     default:
  859.       BAD_CASE (fragP->fr_subtype);
  860.       break;
  861.     }
  862.   fragP->fr_fix += extension;
  863. }                /* md_convert_frag */
  864.  
  865.  
  866. /* This is the stuff for md_assemble. */
  867. #define FP_REG 13
  868. #define SP_REG 14
  869. #define PC_REG 15
  870. #define BIGGESTREG PC_REG
  871.  
  872. /*
  873.  * Parse the string pointed to by START
  874.  * If it represents a valid register, point START to the character after
  875.  * the last valid register char, and return the register number (0-15).
  876.  * If invalid, leave START alone, return -1.
  877.  * The format has to be exact. I don't do things like eat leading zeros
  878.  * or the like.
  879.  * Note: This doesn't check for the next character in the string making
  880.  * this invalid. Ex: R123 would return 12, it's the callers job to check
  881.  * what start is point to apon return.
  882.  *
  883.  * Valid registers are R1-R15, %1-%15, FP (13), SP (14), PC (15)
  884.  * Case doesn't matter.
  885.  */
  886. int
  887. tahoe_reg_parse (start)
  888.      char **start;        /* A pointer to the string to parse. */
  889. {
  890.   register char *regpoint = *start;
  891.   register int regnum = -1;
  892.  
  893.   switch (*regpoint++)
  894.     {
  895.     case '%':            /* Registers can start with a %,
  896.                    R or r, and then a number. */
  897.     case 'R':
  898.     case 'r':
  899.       if (isdigit (*regpoint))
  900.     {
  901.       /* Got the first digit. */
  902.       regnum = *regpoint++ - '0';
  903.       if ((regnum == 1) && isdigit (*regpoint))
  904.         {
  905.           /* Its a two digit number. */
  906.           regnum = 10 + (*regpoint++ - '0');
  907.           if (regnum > BIGGESTREG)
  908.         {        /* Number too big? */
  909.           regnum = -1;
  910.         }
  911.         }
  912.     }
  913.       break;
  914.     case 'F':            /* Is it the FP */
  915.     case 'f':
  916.       switch (*regpoint++)
  917.     {
  918.     case 'p':
  919.     case 'P':
  920.       regnum = FP_REG;
  921.     }
  922.       break;
  923.     case 's':            /* How about the SP */
  924.     case 'S':
  925.       switch (*regpoint++)
  926.     {
  927.     case 'p':
  928.     case 'P':
  929.       regnum = SP_REG;
  930.     }
  931.       break;
  932.     case 'p':            /* OR the PC even */
  933.     case 'P':
  934.       switch (*regpoint++)
  935.     {
  936.     case 'c':
  937.     case 'C':
  938.       regnum = PC_REG;
  939.     }
  940.       break;
  941.     }
  942.  
  943.   if (regnum != -1)
  944.     {                /* No error, so move string pointer */
  945.       *start = regpoint;
  946.     }
  947.   return regnum;        /* Return results */
  948. }                /* tahoe_reg_parse */
  949.  
  950. /*
  951.  * This chops up an operand and figures out its modes and stuff.
  952.  * It's a little touchy about extra characters.
  953.  * Optex to start with one extra character so it can be overwritten for
  954.  * the backward part of the parsing.
  955.  * You can't put a bunch of extra characters in side to
  956.  * make the command look cute. ie: * foo ( r1 ) [  r0 ]
  957.  * If you like doing a lot of typing, try COBOL!
  958.  * Actually, this parser is a little weak all around. It's designed to be
  959.  * used with compliers, so I emphisise correct decoding of valid code quickly
  960.  * rather that catching every possable error.
  961.  * Note: This uses the expression function, so save input_line_pointer before
  962.  * calling.
  963.  *
  964.  * Sperry defines the semantics of address modes (and values)
  965.  * by a two-letter code, explained here.
  966.  *
  967.  *   letter 1:   access type
  968.  *
  969.  *     a         address calculation - no data access, registers forbidden
  970.  *     b         branch displacement
  971.  *     m         read - let go of bus - write back "modify"
  972.  *     r         read
  973.  *     w         write
  974.  *     v         bit field address: like 'a' but registers are OK
  975.  *
  976.  *   letter 2:   data type (i.e. width, alignment)
  977.  *
  978.  *     b         byte
  979.  *     w         word
  980.  *     l         longword
  981.  *     q         quadword (Even regs < 14 allowed) (if 12, you get a warning)
  982.  *     -     unconditional synthetic jbr operand
  983.  *     ?     simple synthetic reversable branch operand
  984.  *     !     complex synthetic reversable branch operand
  985.  *     :     complex synthetic non-reversable branch operand
  986.  *
  987.  * The '-?!:' letter 2's are not for external consumption. They are used
  988.  * by GAS for psuedo ops relaxing code.
  989.  *
  990.  * After parsing topP has:
  991.  *
  992.  *   top_ndx:        -1, or the index register. eg 7=[R7]
  993.  *   top_reg:        -1, or register number. eg 7 = R7 or (R7)
  994.  *   top_mode:       The addressing mode byte. This byte, defines which of
  995.  *                   the 11 modes opcode is.
  996.  *   top_access:     Access type wanted for this opperand 'b'branch ' '
  997.  *                   no-instruction 'amrvw'
  998.  *   top_width:      Operand width expected, one of "bwlq?-:!"
  999.  *   exp_of_operand: The expression as parsed by expression()
  1000.  *   top_dispsize:   Number of bytes in the displacement if we can figure it
  1001.  *                   out and it's relavent.
  1002.  *
  1003.  * Need syntax checks built.
  1004.  */
  1005.  
  1006. void
  1007. tip_op (optex, topP)
  1008.      char *optex;        /* The users text input, with one leading character */
  1009.      struct top *topP;        /* The tahoe instruction with some fields already set:
  1010.              in: access, width
  1011.              out: ndx, reg, mode, error, dispsize */
  1012.  
  1013. {
  1014.   int mode = 0;            /* This operand's mode. */
  1015.   char segfault = *optex;    /* To keep the back parsing from freaking. */
  1016.   char *point = optex + 1;    /* Parsing from front to back. */
  1017.   char *end;            /* Parsing from back to front. */
  1018.   int reg = -1;            /* major register, -1 means absent */
  1019.   int imreg = -1;        /* Major register in immediate mode */
  1020.   int ndx = -1;            /* index register number, -1 means absent */
  1021.   char dec_inc = ' ';        /* Is the SP auto-incremented '+' or
  1022.                    auto-decremented '-' or neither ' '. */
  1023.   int immediate = 0;        /* 1 if '$' immediate mode */
  1024.   int call_width = 0;        /* If the caller casts the displacement */
  1025.   int abs_width = 0;        /* The width of the absolute displacment */
  1026.   int com_width = 0;        /* Displacement width required by branch */
  1027.   int deferred = 0;        /* 1 if '*' deferral is used */
  1028.   byte disp_size = 0;        /* How big is this operand. 0 == don't know */
  1029.   char *op_bad = "";        /* Bad operand error */
  1030.  
  1031.   char *tp, *temp, c;        /* Temporary holders */
  1032.  
  1033.   char access = topP->top_access;    /* Save on a deref. */
  1034.   char width = topP->top_width;
  1035.  
  1036.   int really_none = 0;        /* Empty expressions evaluate to 0
  1037.                    but I need to know if it's there or not */
  1038.   expressionS *expP;        /* -> expression values for this operand */
  1039.  
  1040.   /* Does this command restrict the displacement size. */
  1041.   if (access == 'b')
  1042.     com_width = (width == 'b' ? 1 :
  1043.          (width == 'w' ? 2 :
  1044.           (width == 'l' ? 4 : 0)));
  1045.  
  1046.   *optex = '\0';        /* This is kind of a back stop for all
  1047.                    the searches to fail on if needed.*/
  1048.   if (*point == '*')
  1049.     {                /* A dereference? */
  1050.       deferred = 1;
  1051.       point++;
  1052.     }
  1053.  
  1054.   /* Force words into a certain mode */
  1055.   /* Bitch, Bitch, Bitch! */
  1056.   /*
  1057.    * Using the ^ operator is ambigous. If I have an absolute label
  1058.    * called 'w' set to, say 2, and I have the expression 'w^1', do I get
  1059.    * 1, forced to be in word displacement mode, or do I get the value of
  1060.    * 'w' or'ed with 1 (3 in this case).
  1061.    * The default is 'w' as an offset, so that's what I use.
  1062.    * Stick with `, it does the same, and isn't ambig.
  1063.    */
  1064.  
  1065.   if (*point != '\0' && ((point[1] == '^') || (point[1] == '`')))
  1066.     switch (*point)
  1067.       {
  1068.       case 'b':
  1069.       case 'B':
  1070.       case 'w':
  1071.       case 'W':
  1072.       case 'l':
  1073.       case 'L':
  1074.     if (com_width)
  1075.       as_warn ("Casting a branch displacement is bad form, and is ignored.");
  1076.     else
  1077.       {
  1078.         c = (isupper (*point) ? tolower (*point) : *point);
  1079.         call_width = ((c == 'b') ? 1 :
  1080.               ((c == 'w') ? 2 : 4));
  1081.       }
  1082.     point += 2;
  1083.     break;
  1084.       }
  1085.  
  1086.   /* Setting immediate mode */
  1087.   if (*point == '$')
  1088.     {
  1089.       immediate = 1;
  1090.       point++;
  1091.     }
  1092.  
  1093.   /*
  1094.    * I've pulled off all the easy stuff off the front, move to the end and
  1095.    * yank.
  1096.    */
  1097.  
  1098.   for (end = point; *end != '\0'; end++)    /* Move to the end. */
  1099.     ;
  1100.  
  1101.   if (end != point)        /* Null string? */
  1102.     end--;
  1103.  
  1104.   if (end > point && *end == ' ' && end[-1] != '\'')
  1105.     end--;            /* Hop white space */
  1106.  
  1107.   /* Is this an index reg. */
  1108.   if ((*end == ']') && (end[-1] != '\''))
  1109.     {
  1110.       temp = end;
  1111.  
  1112.       /* Find opening brace. */
  1113.       for (--end; (*end != '[' && end != point); end--)
  1114.     ;
  1115.  
  1116.       /* If I found the opening brace, get the index register number. */
  1117.       if (*end == '[')
  1118.     {
  1119.       tp = end + 1;        /* tp should point to the start of a reg. */
  1120.       ndx = tahoe_reg_parse (&tp);
  1121.       if (tp != temp)
  1122.         {            /* Reg. parse error. */
  1123.           ndx = -1;
  1124.         }
  1125.       else
  1126.         {
  1127.           end--;        /* Found it, move past brace. */
  1128.         }
  1129.       if (ndx == -1)
  1130.         {
  1131.           op_bad = "Couldn't parse the [index] in this operand.";
  1132.           end = point;    /* Force all the rest of the tests to fail. */
  1133.         }
  1134.     }
  1135.       else
  1136.     {
  1137.       op_bad = "Couldn't find the opening '[' for the index of this operand.";
  1138.       end = point;        /* Force all the rest of the tests to fail. */
  1139.     }
  1140.     }
  1141.  
  1142.   /* Post increment? */
  1143.   if (*end == '+')
  1144.     {
  1145.       dec_inc = '+';
  1146.       /* was:    *end--; */
  1147.       end--;
  1148.     }
  1149.  
  1150.   /* register in parens? */
  1151.   if ((*end == ')') && (end[-1] != '\''))
  1152.     {
  1153.       temp = end;
  1154.  
  1155.       /* Find opening paren. */
  1156.       for (--end; (*end != '(' && end != point); end--)
  1157.     ;
  1158.  
  1159.       /* If I found the opening paren, get the register number. */
  1160.       if (*end == '(')
  1161.     {
  1162.       tp = end + 1;
  1163.       reg = tahoe_reg_parse (&tp);
  1164.       if (tp != temp)
  1165.         {
  1166.           /* Not a register, but could be part of the expression. */
  1167.           reg = -1;
  1168.           end = temp;    /* Rest the pointer back */
  1169.         }
  1170.       else
  1171.         {
  1172.           end--;        /* Found the reg. move before opening paren. */
  1173.         }
  1174.     }
  1175.       else
  1176.     {
  1177.       op_bad = "Couldn't find the opening '(' for the deref of this operand.";
  1178.       end = point;        /* Force all the rest of the tests to fail. */
  1179.     }
  1180.     }
  1181.  
  1182.   /* Pre decrement? */
  1183.   if (*end == '-')
  1184.     {
  1185.       if (dec_inc != ' ')
  1186.     {
  1187.       op_bad = "Operand can't be both pre-inc and post-dec.";
  1188.       end = point;
  1189.     }
  1190.       else
  1191.     {
  1192.       dec_inc = '-';
  1193.       /* was:      *end--; */
  1194.       end--;
  1195.     }
  1196.     }
  1197.  
  1198.   /*
  1199.    * Everything between point and end is the 'expression', unless it's
  1200.    * a register name.
  1201.    */
  1202.  
  1203.   c = end[1];
  1204.   end[1] = '\0';
  1205.  
  1206.   tp = point;
  1207.   imreg = tahoe_reg_parse (&point);    /* Get the immediate register
  1208.                       if it is there.*/
  1209.   if (*point != '\0')
  1210.     {
  1211.       /* If there is junk after point, then the it's not immediate reg. */
  1212.       point = tp;
  1213.       imreg = -1;
  1214.     }
  1215.  
  1216.   if (imreg != -1 && reg != -1)
  1217.     op_bad = "I parsed 2 registers in this operand.";
  1218.  
  1219.   /*
  1220.    * Evaluate whats left of the expression to see if it's valid.
  1221.    * Note again: This assumes that the calling expression has saved
  1222.    * input_line_pointer. (Nag, nag, nag!)
  1223.    */
  1224.  
  1225.   if (*op_bad == '\0')
  1226.     {
  1227.       /* statement has no syntax goofs yet: lets sniff the expression */
  1228.       input_line_pointer = point;
  1229.       expP = &(topP->exp_of_operand);
  1230.       topP->seg_of_operand = expression (expP);
  1231.       switch (expP->X_op)
  1232.     {
  1233.     case O_absent:
  1234.       /* No expression. For BSD4.2 compatibility, missing expression is
  1235.          absolute 0 */
  1236.       expP->X_op = O_constant;
  1237.       expP->X_add_number = 0;
  1238.       really_none = 1;
  1239.     case O_constant:
  1240.       /* for SEG_ABSOLUTE, we shouldnt need to set X_op_symbol,
  1241.          X_add_symbol to any particular value. */
  1242.       /* But, we will program defensively. Since this situation occurs
  1243.          rarely so it costs us little to do so. */
  1244.       expP->X_add_symbol = NULL;
  1245.       expP->X_op_symbol = NULL;
  1246.       /* How many bytes are needed to express this abs value? */
  1247.       abs_width =
  1248.         ((((expP->X_add_number & 0xFFFFFF80) == 0) ||
  1249.           ((expP->X_add_number & 0xFFFFFF80) == 0xFFFFFF80)) ? 1 :
  1250.          (((expP->X_add_number & 0xFFFF8000) == 0) ||
  1251.           ((expP->X_add_number & 0xFFFF8000) == 0xFFFF8000)) ? 2 : 4);
  1252.  
  1253.     case O_symbol:
  1254.       break;
  1255.  
  1256.     default:
  1257.       /*
  1258.        * Major bug. We can't handle the case of a operator
  1259.        * expression in a synthetic opcode variable-length
  1260.        * instruction.  We don't have a frag type that is smart
  1261.        * enough to relax a operator, and so we just force all
  1262.        * operators to behave like SEG_PASS1s.  Clearly, if there is
  1263.        * a demand we can invent a new or modified frag type and
  1264.        * then coding up a frag for this case will be easy.
  1265.        */
  1266.       need_pass_2 = 1;
  1267.       op_bad = "Can't relocate expression error.";
  1268.       break;
  1269.  
  1270.     case O_big:
  1271.       /* This is an error. Tahoe doesn't allow any expressions
  1272.          bigger that a 32 bit long word. Any bigger has to be referenced
  1273.          by address. */
  1274.       op_bad = "Expression is too large for a 32 bits.";
  1275.       break;
  1276.     }
  1277.       if (*input_line_pointer != '\0')
  1278.     {
  1279.       op_bad = "Junk at end of expression.";
  1280.     }
  1281.     }
  1282.  
  1283.   end[1] = c;
  1284.  
  1285.   /* I'm done, so restore optex */
  1286.   *optex = segfault;
  1287.  
  1288.  
  1289.   /*
  1290.    * At this point in the game, we (in theory) have all the components of
  1291.    * the operand at least parsed. Now it's time to check for syntax/semantic
  1292.    * errors, and build the mode.
  1293.    * This is what I have:
  1294.    *   deferred = 1 if '*'
  1295.    *   call_width = 0,1,2,4
  1296.    *   abs_width = 0,1,2,4
  1297.    *   com_width = 0,1,2,4
  1298.    *   immediate = 1 if '$'
  1299.    *   ndx = -1 or reg num
  1300.    *   dec_inc = '-' or '+' or ' '
  1301.    *   reg = -1 or reg num
  1302.    *   imreg = -1 or reg num
  1303.    *   topP->exp_of_operand
  1304.    *   really_none
  1305.    */
  1306.   /* Is there a displacement size? */
  1307.   disp_size = (call_width ? call_width :
  1308.            (com_width ? com_width :
  1309.         abs_width ? abs_width : 0));
  1310.  
  1311.   if (*op_bad == '\0')
  1312.     {
  1313.       if (imreg != -1)
  1314.     {
  1315.       /* Rn */
  1316.       mode = TAHOE_DIRECT_REG;
  1317.       if (deferred || immediate || (dec_inc != ' ') ||
  1318.           (reg != -1) || !really_none)
  1319.         op_bad = "Syntax error in direct register mode.";
  1320.       else if (ndx != -1)
  1321.         op_bad = "You can't index a register in direct register mode.";
  1322.       else if (imreg == SP_REG && access == 'r')
  1323.         op_bad =
  1324.           "SP can't be the source operand with direct register addressing.";
  1325.       else if (access == 'a')
  1326.         op_bad = "Can't take the address of a register.";
  1327.       else if (access == 'b')
  1328.         op_bad = "Direct Register can't be used in a branch.";
  1329.       else if (width == 'q' && ((imreg % 2) || (imreg > 13)))
  1330.         op_bad = "For quad access, the register must be even and < 14.";
  1331.       else if (call_width)
  1332.         op_bad = "You can't cast a direct register.";
  1333.  
  1334.       if (*op_bad == '\0')
  1335.         {
  1336.           /* No errors, check for warnings */
  1337.           if (width == 'q' && imreg == 12)
  1338.         as_warn ("Using reg 14 for quadwords can tromp the FP register.");
  1339.  
  1340.           reg = imreg;
  1341.         }
  1342.  
  1343.       /* We know: imm = -1 */
  1344.     }
  1345.       else if (dec_inc == '-')
  1346.     {
  1347.       /* -(SP) */
  1348.       mode = TAHOE_AUTO_DEC;
  1349.       if (deferred || immediate || !really_none)
  1350.         op_bad = "Syntax error in auto-dec mode.";
  1351.       else if (ndx != -1)
  1352.         op_bad = "You can't have an index auto dec mode.";
  1353.       else if (access == 'r')
  1354.         op_bad = "Auto dec mode cant be used for reading.";
  1355.       else if (reg != SP_REG)
  1356.         op_bad = "Auto dec only works of the SP register.";
  1357.       else if (access == 'b')
  1358.         op_bad = "Auto dec can't be used in a branch.";
  1359.       else if (width == 'q')
  1360.         op_bad = "Auto dec won't work with quadwords.";
  1361.  
  1362.       /* We know: imm = -1, dec_inc != '-' */
  1363.     }
  1364.       else if (dec_inc == '+')
  1365.     {
  1366.       if (immediate || !really_none)
  1367.         op_bad = "Syntax error in one of the auto-inc modes.";
  1368.       else if (deferred)
  1369.         {
  1370.           /* *(SP)+ */
  1371.           mode = TAHOE_AUTO_INC_DEFERRED;
  1372.           if (reg != SP_REG)
  1373.         op_bad = "Auto inc deferred only works of the SP register.";
  1374.           else if (ndx != -1)
  1375.         op_bad = "You can't have an index auto inc deferred mode.";
  1376.           else if (access == 'b')
  1377.         op_bad = "Auto inc can't be used in a branch.";
  1378.         }
  1379.       else
  1380.         {
  1381.           /* (SP)+ */
  1382.           mode = TAHOE_AUTO_INC;
  1383.           if (access == 'm' || access == 'w')
  1384.         op_bad = "You can't write to an auto inc register.";
  1385.           else if (reg != SP_REG)
  1386.         op_bad = "Auto inc only works of the SP register.";
  1387.           else if (access == 'b')
  1388.         op_bad = "Auto inc can't be used in a branch.";
  1389.           else if (width == 'q')
  1390.         op_bad = "Auto inc won't work with quadwords.";
  1391.           else if (ndx != -1)
  1392.         op_bad = "You can't have an index in auto inc mode.";
  1393.         }
  1394.  
  1395.       /* We know: imm = -1, dec_inc == ' ' */
  1396.     }
  1397.       else if (reg != -1)
  1398.     {
  1399.       if ((ndx != -1) && (reg == SP_REG))
  1400.         op_bad = "You can't index the sp register.";
  1401.       if (deferred)
  1402.         {
  1403.           /* *<disp>(Rn) */
  1404.           mode = TAHOE_REG_DISP_DEFERRED;
  1405.           if (immediate)
  1406.         op_bad = "Syntax error in register displaced mode.";
  1407.         }
  1408.       else if (really_none)
  1409.         {
  1410.           /* (Rn) */
  1411.           mode = TAHOE_REG_DEFERRED;
  1412.           /* if reg = SP then cant be indexed */
  1413.         }
  1414.       else
  1415.         {
  1416.           /* <disp>(Rn) */
  1417.           mode = TAHOE_REG_DISP;
  1418.         }
  1419.  
  1420.       /* We know: imm = -1, dec_inc == ' ', Reg = -1 */
  1421.     }
  1422.       else
  1423.     {
  1424.       if (really_none)
  1425.         op_bad = "An offest is needed for this operand.";
  1426.       if (deferred && immediate)
  1427.         {
  1428.           /* *$<ADDR> */
  1429.           mode = TAHOE_ABSOLUTE_ADDR;
  1430.           disp_size = 4;
  1431.         }
  1432.       else if (immediate)
  1433.         {
  1434.           /* $<disp> */
  1435.           mode = TAHOE_IMMEDIATE;
  1436.           if (ndx != -1)
  1437.         op_bad = "You can't index a register in immediate mode.";
  1438.           if (access == 'a')
  1439.         op_bad = "Immediate access can't be used as an address.";
  1440.           /* ponder the wisdom of a cast because it doesn't do any good. */
  1441.         }
  1442.       else if (deferred)
  1443.         {
  1444.           /* *<disp> */
  1445.           mode = TAHOE_DISP_REL_DEFERRED;
  1446.         }
  1447.       else
  1448.         {
  1449.           /* <disp> */
  1450.           mode = TAHOE_DISPLACED_RELATIVE;
  1451.         }
  1452.     }
  1453.     }
  1454.  
  1455.   /*
  1456.    * At this point, all the errors we can do have be checked for.
  1457.    * We can build the 'top'. */
  1458.  
  1459.   topP->top_ndx = ndx;
  1460.   topP->top_reg = reg;
  1461.   topP->top_mode = mode;
  1462.   topP->top_error = op_bad;
  1463.   topP->top_dispsize = disp_size;
  1464. }                /* tip_op */
  1465.  
  1466. /*
  1467.  *                  t i p ( )
  1468.  *
  1469.  * This converts a string into a tahoe instruction.
  1470.  * The string must be a bare single instruction in tahoe (with BSD4 frobs)
  1471.  * format.
  1472.  * It provides at most one fatal error message (which stops the scan)
  1473.  * some warning messages as it finds them.
  1474.  * The tahoe instruction is returned in exploded form.
  1475.  *
  1476.  * The exploded instruction is returned to a struct tit of your choice.
  1477.  * #include "tahoe-inst.h" to know what a struct tit is.
  1478.  *
  1479.  */
  1480.  
  1481. static void
  1482. tip (titP, instring)
  1483.      struct tit *titP;        /* We build an exploded instruction here. */
  1484.      char *instring;        /* Text of a vax instruction: we modify. */
  1485. {
  1486.   register struct tot_wot *twP = NULL;    /* How to bit-encode this opcode. */
  1487.   register char *p;        /* 1/skip whitespace.2/scan vot_how */
  1488.   register char *q;        /*  */
  1489.   register unsigned char count;    /* counts number of operands seen */
  1490.   register struct top *operandp;/* scan operands in struct tit */
  1491.   register char *alloperr = "";    /* error over all operands */
  1492.   register char c;        /* Remember char, (we clobber it
  1493.                    with '\0' temporarily). */
  1494.   char *save_input_line_pointer;
  1495.  
  1496.   if (*instring == ' ')
  1497.     ++instring;            /* Skip leading whitespace. */
  1498.   for (p = instring; *p && *p != ' '; p++)
  1499.     ;                /* MUST end in end-of-string or
  1500.                    exactly 1 space. */
  1501.   /* Scanned up to end of operation-code. */
  1502.   /* Operation-code is ended with whitespace. */
  1503.   if (p == instring)
  1504.     {
  1505.       titP->tit_error = "No operator";
  1506.       count = 0;
  1507.       titP->tit_opcode = 0;
  1508.     }
  1509.   else
  1510.     {
  1511.       c = *p;
  1512.       *p = '\0';
  1513.       /*
  1514.      * Here with instring pointing to what better be an op-name, and p
  1515.      * pointing to character just past that.
  1516.      * We trust instring points to an op-name, with no whitespace.
  1517.      */
  1518.       twP = (struct tot_wot *) hash_find (op_hash, instring);
  1519.       *p = c;            /* Restore char after op-code. */
  1520.       if (twP == 0)
  1521.     {
  1522.       titP->tit_error = "Unknown operator";
  1523.       count = 0;
  1524.       titP->tit_opcode = 0;
  1525.     }
  1526.       else
  1527.     {
  1528.       /*
  1529.        * We found a match! So lets pick up as many operands as the
  1530.        * instruction wants, and even gripe if there are too many.
  1531.        * We expect comma to seperate each operand.
  1532.        * We let instring track the text, while p tracks a part of the
  1533.        * struct tot.
  1534.        */
  1535.  
  1536.       count = 0;        /* no operands seen yet */
  1537.       instring = p + (*p != '\0');    /* point past the operation code */
  1538.       /* tip_op() screws with the input_line_pointer, so save it before
  1539.      I jump in */
  1540.       save_input_line_pointer = input_line_pointer;
  1541.       for (p = twP->args, operandp = titP->tit_operand;
  1542.            !*alloperr && *p;
  1543.            operandp++, p += 2)
  1544.         {
  1545.           /*
  1546.      * Here to parse one operand. Leave instring pointing just
  1547.      * past any one ',' that marks the end of this operand.
  1548.      */
  1549.           if (!p[1])
  1550.         as_fatal ("Compiler bug: ODD number of bytes in arg structure %s.",
  1551.               twP->args);
  1552.           else if (*instring)
  1553.         {
  1554.           for (q = instring; (*q != ',' && *q != '\0'); q++)
  1555.             {
  1556.               if (*q == '\'' && q[1] != '\0')    /* Jump quoted characters */
  1557.             q++;
  1558.             }
  1559.           c = *q;
  1560.           /*
  1561.        * Q points to ',' or '\0' that ends argument. C is that
  1562.        * character.
  1563.        */
  1564.           *q = '\0';
  1565.           operandp->top_access = p[0];
  1566.           operandp->top_width = p[1];
  1567.           tip_op (instring - 1, operandp);
  1568.           *q = c;    /* Restore input text. */
  1569.           if (*(operandp->top_error))
  1570.             {
  1571.               alloperr = operandp->top_error;
  1572.             }
  1573.           instring = q + (c ? 1 : 0);    /* next operand (if any) */
  1574.           count++;    /*  won another argument, may have an operr */
  1575.         }
  1576.           else
  1577.         alloperr = "Not enough operands";
  1578.         }
  1579.       /* Restore the pointer. */
  1580.       input_line_pointer = save_input_line_pointer;
  1581.  
  1582.       if (!*alloperr)
  1583.         {
  1584.           if (*instring == ' ')
  1585.         instring++;    /* Skip whitespace. */
  1586.           if (*instring)
  1587.         alloperr = "Too many operands";
  1588.         }
  1589.       titP->tit_error = alloperr;
  1590.     }
  1591.     }
  1592.  
  1593.   titP->tit_opcode = twP->code;    /* The op-code. */
  1594.   titP->tit_operands = count;
  1595. }                /* tip */
  1596.  
  1597. /* md_assemble() emit frags for 1 instruction */
  1598. void
  1599. md_assemble (instruction_string)
  1600.      char *instruction_string;    /* A string: assemble 1 instruction. */
  1601. {
  1602.   char *p;
  1603.   register struct top *operandP;/* An operand. Scans all operands. */
  1604.   /*  char c_save;    fixme: remove this line *//* What used to live after an expression. */
  1605.   /*  struct frag *fragP;    fixme: remove this line *//* Fragment of code we just made. */
  1606.   /*  register struct top *end_operandP; fixme: remove this line *//* -> slot just after last operand
  1607.                     Limit of the for (each operand). */
  1608.   register expressionS *expP;    /* -> expression values for this operand */
  1609.  
  1610.   /* These refer to an instruction operand expression. */
  1611.   segT to_seg;            /* Target segment of the address.     */
  1612.  
  1613.   register valueT this_add_number;
  1614.   register struct symbol *this_add_symbol;    /* +ve (minuend) symbol. */
  1615.  
  1616.   /*  tahoe_opcodeT opcode_as_number; fixme: remove this line *//* The opcode as a number. */
  1617.   char *opcodeP;        /* Where it is in a frag. */
  1618.   /*  char *opmodeP;    fixme: remove this line *//* Where opcode type is, in a frag. */
  1619.  
  1620.   int dispsize;            /* From top_dispsize: tahoe_operand_width
  1621.                    (in bytes) */
  1622.   int is_undefined;        /* 1 if operand expression's
  1623.                    segment not known yet. */
  1624.   int pc_rel;            /* Is this operand pc relative? */
  1625.  
  1626.   /* Decode the operand. */
  1627.   tip (&t, instruction_string);
  1628.  
  1629.   /*
  1630.    * Check to see if this operand decode properly.
  1631.    * Notice that we haven't made any frags yet.
  1632.    * If it goofed, then this instruction will wedge in any pass,
  1633.    * and we can safely flush it, without causing interpass symbol phase
  1634.    * errors. That is, without changing label values in different passes.
  1635.    */
  1636.   if (*t.tit_error)
  1637.     {
  1638.       as_warn ("Ignoring statement due to \"%s\"", t.tit_error);
  1639.     }
  1640.   else
  1641.     {
  1642.       /* We saw no errors in any operands - try to make frag(s) */
  1643.       /* Emit op-code. */
  1644.       /* Remember where it is, in case we want to modify the op-code later. */
  1645.       opcodeP = frag_more (1);
  1646.       *opcodeP = t.tit_opcode;
  1647.       /* Now do each operand. */
  1648.       for (operandP = t.tit_operand;
  1649.        operandP < t.tit_operand + t.tit_operands;
  1650.        operandP++)
  1651.     {            /* for each operand */
  1652.       expP = &(operandP->exp_of_operand);
  1653.       if (operandP->top_ndx >= 0)
  1654.         {
  1655.           /* Indexed addressing byte
  1656.        Legality of indexed mode already checked: it is OK */
  1657.           FRAG_APPEND_1_CHAR (0x40 + operandP->top_ndx);
  1658.         }            /* if(top_ndx>=0) */
  1659.  
  1660.       /* Here to make main operand frag(s). */
  1661.       this_add_number = expP->X_add_number;
  1662.       this_add_symbol = expP->X_add_symbol;
  1663.       to_seg = operandP->seg_of_operand;
  1664.       know (to_seg == SEG_UNKNOWN || \
  1665.         to_seg == SEG_ABSOLUTE || \
  1666.         to_seg == SEG_DATA || \
  1667.         to_seg == SEG_TEXT || \
  1668.         to_seg == SEG_BSS);
  1669.       is_undefined = (to_seg == SEG_UNKNOWN);
  1670.       /* Do we know how big this opperand is? */
  1671.       dispsize = operandP->top_dispsize;
  1672.       pc_rel = 0;
  1673.       /* Deal with the branch possabilities. (Note, this doesn't include
  1674.      jumps.)*/
  1675.       if (operandP->top_access == 'b')
  1676.         {
  1677.           /* Branches must be expressions. A psuedo branch can also jump to
  1678.        an absolute address. */
  1679.           if (to_seg == now_seg || is_undefined)
  1680.         {
  1681.           /* If is_undefined, then it might BECOME now_seg by relax time. */
  1682.           if (dispsize)
  1683.             {
  1684.               /* I know how big the branch is supposed to be (it's a normal
  1685.            branch), so I set up the frag, and let GAS do the rest. */
  1686.               p = frag_more (dispsize);
  1687.               fix_new (frag_now, p - frag_now->fr_literal,
  1688.                    this_add_symbol, this_add_number,
  1689.                    size_to_fx (dispsize, 1),
  1690.                    NULL);
  1691.             }
  1692.           else
  1693.             {
  1694.               /* (to_seg==now_seg || to_seg == SEG_UNKNOWN) && dispsize==0 */
  1695.               /* If we don't know how big it is, then its a synthetic branch,
  1696.            so we set up a simple relax state. */
  1697.               switch (operandP->top_width)
  1698.             {
  1699.             case TAHOE_WIDTH_CONDITIONAL_JUMP:
  1700.               /* Simple (conditional) jump. I may have to reverse the
  1701.          condition of opcodeP, and then jump to my destination.
  1702.          I set 1 byte aside for the branch off set, and could need 6
  1703.          more bytes for the pc_rel jump */
  1704.               frag_var (rs_machine_dependent, 7, 1,
  1705.                     ENCODE_RELAX (STATE_CONDITIONAL_BRANCH,
  1706.                     is_undefined ? STATE_UNDF : STATE_BYTE),
  1707.                  this_add_symbol, this_add_number, opcodeP);
  1708.               break;
  1709.             case TAHOE_WIDTH_ALWAYS_JUMP:
  1710.               /* Simple (unconditional) jump. I may have to convert this to
  1711.          a word branch, or an absolute jump. */
  1712.               frag_var (rs_machine_dependent, 5, 1,
  1713.                     ENCODE_RELAX (STATE_ALWAYS_BRANCH,
  1714.                     is_undefined ? STATE_UNDF : STATE_BYTE),
  1715.                  this_add_symbol, this_add_number, opcodeP);
  1716.               break;
  1717.               /* The smallest size for the next 2 cases is word. */
  1718.             case TAHOE_WIDTH_BIG_REV_JUMP:
  1719.               frag_var (rs_machine_dependent, 8, 2,
  1720.                     ENCODE_RELAX (STATE_BIG_REV_BRANCH,
  1721.                     is_undefined ? STATE_UNDF : STATE_WORD),
  1722.                     this_add_symbol, this_add_number,
  1723.                     opcodeP);
  1724.               break;
  1725.             case TAHOE_WIDTH_BIG_NON_REV_JUMP:
  1726.               frag_var (rs_machine_dependent, 10, 2,
  1727.                     ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH,
  1728.                     is_undefined ? STATE_UNDF : STATE_WORD),
  1729.                     this_add_symbol, this_add_number,
  1730.                     opcodeP);
  1731.               break;
  1732.             default:
  1733.               as_fatal ("Compliler bug: Got a case (%d) I wasn't expecting.",
  1734.                     operandP->top_width);
  1735.             }
  1736.             }
  1737.         }
  1738.           else
  1739.         {
  1740.           /* to_seg != now_seg && to_seg != seg_unknown (still in branch)
  1741.          In other words, I'm jumping out of my segment so extend the
  1742.          branches to jumps, and let GAS fix them. */
  1743.  
  1744.           /* These are "branches" what will always be branches around a jump
  1745.          to the correct addresss in real life.
  1746.          If to_seg is SEG_ABSOLUTE, just encode the branch in,
  1747.          else let GAS fix the address. */
  1748.  
  1749.           switch (operandP->top_width)
  1750.             {
  1751.               /* The theory:
  1752.            For SEG_ABSOLUTE, then mode is ABSOLUTE_ADDR, jump
  1753.            to that addresss (not pc_rel).
  1754.            For other segs, address is a long word PC rel jump. */
  1755.             case TAHOE_WIDTH_CONDITIONAL_JUMP:
  1756.               /* b<cond> */
  1757.               /* To reverse the condition in a TAHOE branch,
  1758.            complement bit 4 */
  1759.               *opcodeP ^= 0x10;
  1760.               p = frag_more (7);
  1761.               *p++ = 6;
  1762.               *p++ = TAHOE_JMP;
  1763.               *p++ = (operandP->top_mode ==
  1764.                   TAHOE_ABSOLUTE_ADDR ? TAHOE_ABSOLUTE_ADDR :
  1765.                   TAHOE_PC_REL_LONG);
  1766.               fix_new (frag_now, p - frag_now->fr_literal,
  1767.                    this_add_symbol, this_add_number,
  1768.                (to_seg != SEG_ABSOLUTE) ? FX_PCREL32 : FX_32, NULL);
  1769.               /*
  1770.          * Now (eg)    BLEQ    1f
  1771.          *        JMP    foo
  1772.          *    1:
  1773.          */
  1774.               break;
  1775.             case TAHOE_WIDTH_ALWAYS_JUMP:
  1776.               /* br, just turn it into a jump */
  1777.               *opcodeP = TAHOE_JMP;
  1778.               p = frag_more (5);
  1779.               *p++ = (operandP->top_mode ==
  1780.                   TAHOE_ABSOLUTE_ADDR ? TAHOE_ABSOLUTE_ADDR :
  1781.                   TAHOE_PC_REL_LONG);
  1782.               fix_new (frag_now, p - frag_now->fr_literal,
  1783.                    this_add_symbol, this_add_number,
  1784.                (to_seg != SEG_ABSOLUTE) ? FX_PCREL32 : FX_32, NULL);
  1785.               /* Now (eg) JMP foo */
  1786.               break;
  1787.             case TAHOE_WIDTH_BIG_REV_JUMP:
  1788.               p = frag_more (8);
  1789.               *opcodeP ^= 0x10;
  1790.               *p++ = 0;
  1791.               *p++ = 6;
  1792.               *p++ = TAHOE_JMP;
  1793.               *p++ = (operandP->top_mode ==
  1794.                   TAHOE_ABSOLUTE_ADDR ? TAHOE_ABSOLUTE_ADDR :
  1795.                   TAHOE_PC_REL_LONG);
  1796.               fix_new (frag_now, p - frag_now->fr_literal,
  1797.                    this_add_symbol, this_add_number,
  1798.                (to_seg != SEG_ABSOLUTE) ? FX_PCREL32 : FX_32, NULL);
  1799.               /*
  1800.          * Now (eg)    ACBx    1f
  1801.          *        JMP     foo
  1802.          *    1:
  1803.          */
  1804.               break;
  1805.             case TAHOE_WIDTH_BIG_NON_REV_JUMP:
  1806.               p = frag_more (10);
  1807.               *p++ = 0;
  1808.               *p++ = 2;
  1809.               *p++ = TAHOE_BRB;
  1810.               *p++ = 6;
  1811.               *p++ = TAHOE_JMP;
  1812.               *p++ = (operandP->top_mode ==
  1813.                   TAHOE_ABSOLUTE_ADDR ? TAHOE_ABSOLUTE_ADDR :
  1814.                   TAHOE_PC_REL_LONG);
  1815.               fix_new (frag_now, p - frag_now->fr_literal,
  1816.                    this_add_symbol, this_add_number,
  1817.                (to_seg != SEG_ABSOLUTE) ? FX_PCREL32 : FX_32, NULL);
  1818.               /*
  1819.          * Now (eg)    xOBxxx    1f
  1820.          *        BRB    2f
  1821.          *    1:    JMP    @#foo
  1822.          *    2:
  1823.          */
  1824.               break;
  1825.             case 'b':
  1826.             case 'w':
  1827.               as_warn ("Real branch displacements must be expressions.");
  1828.               break;
  1829.             default:
  1830.               as_fatal ("Complier error: I got an unknown synthetic branch :%c",
  1831.                 operandP->top_width);
  1832.               break;
  1833.             }
  1834.         }
  1835.         }
  1836.       else
  1837.         {
  1838.           /* It ain't a branch operand. */
  1839.           switch (operandP->top_mode)
  1840.         {
  1841.           /* Auto-foo access, only works for one reg (SP)
  1842.          so the only thing needed is the mode. */
  1843.         case TAHOE_AUTO_DEC:
  1844.         case TAHOE_AUTO_INC:
  1845.         case TAHOE_AUTO_INC_DEFERRED:
  1846.           FRAG_APPEND_1_CHAR (operandP->top_mode);
  1847.           break;
  1848.  
  1849.           /* Numbered Register only access. Only thing needed is the
  1850.          mode + Register number */
  1851.         case TAHOE_DIRECT_REG:
  1852.         case TAHOE_REG_DEFERRED:
  1853.           FRAG_APPEND_1_CHAR (operandP->top_mode + operandP->top_reg);
  1854.           break;
  1855.  
  1856.           /* An absolute address. It's size is always 5 bytes.
  1857.          (mode_type + 4 byte address). */
  1858.         case TAHOE_ABSOLUTE_ADDR:
  1859.           know ((this_add_symbol == NULL));
  1860.           p = frag_more (5);
  1861.           *p = TAHOE_ABSOLUTE_ADDR;
  1862.           md_number_to_chars (p + 1, this_add_number, 4);
  1863.           break;
  1864.  
  1865.           /* Immediate data. If the size isn't known, then it's an address
  1866.          + and offset, which is 4 bytes big. */
  1867.         case TAHOE_IMMEDIATE:
  1868.           if (this_add_symbol != NULL)
  1869.             {
  1870.               p = frag_more (5);
  1871.               *p++ = TAHOE_IMMEDIATE_LONGWORD;
  1872.               fix_new (frag_now, p - frag_now->fr_literal,
  1873.                    this_add_symbol, this_add_number,
  1874.                    FX_32, NULL);
  1875.             }
  1876.           else
  1877.             {
  1878.               /* It's a integer, and I know it's size. */
  1879.               if ((unsigned) this_add_number < 0x40)
  1880.             {
  1881.               /* Will it fit in a literal? */
  1882.               FRAG_APPEND_1_CHAR ((byte) this_add_number);
  1883.             }
  1884.               else
  1885.             {
  1886.               p = frag_more (dispsize + 1);
  1887.               switch (dispsize)
  1888.                 {
  1889.                 case 1:
  1890.                   *p++ = TAHOE_IMMEDIATE_BYTE;
  1891.                   *p = (byte) this_add_number;
  1892.                   break;
  1893.                 case 2:
  1894.                   *p++ = TAHOE_IMMEDIATE_WORD;
  1895.                   md_number_to_chars (p, this_add_number, 2);
  1896.                   break;
  1897.                 case 4:
  1898.                   *p++ = TAHOE_IMMEDIATE_LONGWORD;
  1899.                   md_number_to_chars (p, this_add_number, 4);
  1900.                   break;
  1901.                 }
  1902.             }
  1903.             }
  1904.           break;
  1905.  
  1906.           /* Distance from the PC. If the size isn't known, we have to relax
  1907.          into it. The difference between this and disp(sp) is that
  1908.          this offset is pc_rel, and disp(sp) isn't.
  1909.          Note the drop through code. */
  1910.  
  1911.         case TAHOE_DISPLACED_RELATIVE:
  1912.         case TAHOE_DISP_REL_DEFERRED:
  1913.           operandP->top_reg = PC_REG;
  1914.           pc_rel = 1;
  1915.  
  1916.           /* Register, plus a displacement mode. Save the register number,
  1917.          and weather its deffered or not, and relax the size if it isn't
  1918.          known. */
  1919.         case TAHOE_REG_DISP:
  1920.         case TAHOE_REG_DISP_DEFERRED:
  1921.           if (operandP->top_mode == TAHOE_DISP_REL_DEFERRED ||
  1922.               operandP->top_mode == TAHOE_REG_DISP_DEFERRED)
  1923.             operandP->top_reg += 0x10;    /* deffered mode is always 0x10 higher
  1924.                       than it's non-deffered sibling. */
  1925.  
  1926.           /* Is this a value out of this segment?
  1927.          The first part of this conditional is a cludge to make gas
  1928.          produce the same output as 'as' when there is a lable, in
  1929.          the current segment, displaceing a register. It's strange,
  1930.          and no one in their right mind would do it, but it's easy
  1931.          to cludge. */
  1932.           if ((dispsize == 0 && !pc_rel) ||
  1933.               (to_seg != now_seg && !is_undefined && to_seg != SEG_ABSOLUTE))
  1934.             dispsize = 4;
  1935.  
  1936.           if (dispsize == 0)
  1937.             {
  1938.               /*
  1939.          * We have a SEG_UNKNOWN symbol, or the size isn't cast.
  1940.          * It might turn out to be in the same segment as
  1941.          * the instruction, permitting relaxation.
  1942.          */
  1943.               p = frag_var (rs_machine_dependent, 5, 2,
  1944.                     ENCODE_RELAX (STATE_PC_RELATIVE,
  1945.                     is_undefined ? STATE_UNDF : STATE_BYTE),
  1946.                     this_add_symbol, this_add_number, 0);
  1947.               *p = operandP->top_reg;
  1948.             }
  1949.           else
  1950.             {
  1951.               /* Either this is an abs, or a cast. */
  1952.               p = frag_more (dispsize + 1);
  1953.               switch (dispsize)
  1954.             {
  1955.             case 1:
  1956.               *p = TAHOE_PC_OR_BYTE + operandP->top_reg;
  1957.               break;
  1958.             case 2:
  1959.               *p = TAHOE_PC_OR_WORD + operandP->top_reg;
  1960.               break;
  1961.             case 4:
  1962.               *p = TAHOE_PC_OR_LONG + operandP->top_reg;
  1963.               break;
  1964.             };
  1965.               fix_new (frag_now, p + 1 - frag_now->fr_literal,
  1966.                    this_add_symbol, this_add_number,
  1967.                    size_to_fx (dispsize, pc_rel), NULL);
  1968.             }
  1969.           break;
  1970.         default:
  1971.           as_fatal ("Barf, bad mode %x\n", operandP->top_mode);
  1972.         }
  1973.         }
  1974.     }            /* for(operandP) */
  1975.     }                /* if(!need_pass_2 && !goofed) */
  1976. }                /* tahoe_assemble() */
  1977.  
  1978.  
  1979. /* We have no need to default values of symbols. */
  1980.  
  1981. /* ARGSUSED */
  1982. symbolS *
  1983. md_undefined_symbol (name)
  1984.      char *name;
  1985. {
  1986.   return 0;
  1987. }                /* md_undefined_symbol() */
  1988.  
  1989. /* Round up a section size to the appropriate boundary. */
  1990. valueT
  1991. md_section_align (segment, size)
  1992.      segT segment;
  1993.      valueT size;
  1994. {
  1995.   return ((size + 7) & ~7);    /* Round all sects to multiple of 8 */
  1996. }                /* md_section_align() */
  1997.  
  1998. /* Exactly what point is a PC-relative offset relative TO?
  1999.    On the sparc, they're relative to the address of the offset, plus
  2000.    its size.  This gets us to the following instruction.
  2001.    (??? Is this right?  FIXME-SOON) */
  2002. long 
  2003. md_pcrel_from (fixP)
  2004.      fixS *fixP;
  2005. {
  2006.   return (((fixP->fx_type == FX_8
  2007.         || fixP->fx_type == FX_PCREL8)
  2008.        ? 1
  2009.        : ((fixP->fx_type == FX_16
  2010.            || fixP->fx_type == FX_PCREL16)
  2011.           ? 2
  2012.           : ((fixP->fx_type == FX_32
  2013.           || fixP->fx_type == FX_PCREL32)
  2014.          ? 4
  2015.          : 0))) + fixP->fx_where + fixP->fx_frag->fr_address);
  2016. }                /* md_pcrel_from() */
  2017.  
  2018. int 
  2019. tc_is_pcrel (fixP)
  2020.      fixS *fixP;
  2021. {
  2022.   /* should never be called */
  2023.   know (0);
  2024.   return (0);
  2025. }                /* tc_is_pcrel() */
  2026.  
  2027. /* end of tc-tahoe.c */
  2028.